Magnum One/Magnum One (Mid-American Digital) (Disc Manufacturing).iso/d12/v8n15.arc/RUN.C

C/C++ Source or Header | 1989-08-31 | 5.1 KB | 197 lines

/* RUN.C */
/* Compile with these options if QuickC: /W3 /Zp /Ox /I$(INCLUDE) /DMSC */
/* Compile with these options if Turbo C: -DTC -O -w -I$(INCLUDE) -L$(LIB) */

#include <stdio.h>
#include <process.h>
#include <string.h>

#if defined(MSC)
#include <malloc.h>
#endif

#if defined(TC)
#include <alloc.h>
#endif

#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>

/*
#include <sys\types.h>
#include <sys\stat.h>
*/

#include <io.h>

void    make_command(char *token);
int     IsCommandCommand(char *command);
void    RunProgram(char *command);
void    NoMemoryExit(void);
void    main(int argc, char **argv);

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

    /* Table of Internal DOS commands */
char *Commandcoms[] =
{
    "CD","CHDIR","CLS","COPY","CTTY","DATE","DEL","DIR","ECHO","ERASE","MD",
    "MKDIR","PATH","PAUSE", "PROMPT","RD","REN","RENAME","RMDIR","SET",
    "TIME","TYPE","VER","VOL",NULL
};

#define    DELIMETER ";"    /* semicolon delimiter */
char *wsdelim = " \\/\t\n"; /* whitespace delimiters */

char *usage = "Usage: run command;command;...\n"
              "or     run - Then enter each command followed by <RETURN>\n";
char *command_prompt = "\nCommand: ";


#define MAXCOMMANDLINE    128        /* command line size */
#define MAXCOMMANDSTACK    100        /* max commands to 'stack' */
#define MAXCOMMANDS        40        /* max command-line commands */

char *runstr[MAXCOMMANDSTACK];    /* pointers to commands     */
int runcnt = 0;

void main(int argc, char **argv)
    {
    char cmdline[MAXCOMMANDLINE+1];    /* buffer for command line */
    char *token;                    /* the associated pointer */
    int n;
    cmdline[0] = '\0';
    if(argc > 1)        /* if arguments */
        {
        argv++;
        while (argc--)
            {
            strcat(cmdline, *argv++);
            strcat(cmdline, " ");
            }

            /* parse out and malloc string for each command (';' separator) */
        for(token = NULL;
                token = strtok((token ? NULL : cmdline), DELIMETER); )
            {
            make_command(token);
            if(runcnt >= MAXCOMMANDS)    /* and quit if too many */
                break;
            }
        }
    else                /* no command-line arguments*/
        {
        printf(command_prompt);

        while(strlen(gets(cmdline)) > 0)
            {
            make_command(cmdline);
            if(runcnt >= MAXCOMMANDS)    /* and quit if too many */
                break;
            printf(command_prompt);
            }
        }

        /* runcnt now has the # of commands given either way,
           and the commands are pointed to by pointers in runstr
         */
    if(!runcnt)        /* no commands given: quit */
        {
        printf(usage);
        exit(1);
        }

    for(n = 0; n < runcnt; n++)        /* process each command */
        {
        printf("\n%s\n", runstr[n]);    /* echo out the command */

        if(IsCommandCommand(runstr[n]))    /* if DOS command */
            {
            if(system(runstr[n]))        /* load COMMAND.COM to run */
                perror("run (DOS cmd)");
            }
        else
            RunProgram(runstr[n]);        /* else run as a program */

        free(runstr[n]);
        }
    exit(0);
    }

void make_command(char *token)
    {
    if(!(runstr[runcnt] = malloc(strlen(token)+1)))
        NoMemoryExit();

    strcpy(runstr[runcnt], token);
    runcnt++;
    }


int IsCommandCommand(char *command)
    {
    register char **p, *token;
    char temp[MAXCOMMANDLINE+1];    /* buffer for command line */
    strcpy(temp,command);
    token = strtok(temp, wsdelim);
    strupr(token);
    for(p = Commandcoms; *p; p++)
        if(!strcmp(*p, token))
            return TRUE;

    return FALSE;
    }


void RunProgram(char *command)
    {
    char *cmd_args[MAXCOMMANDS];    /* array of pointers for spawn */
    char *token;
    int arg = 2, i;
    char *batch_command = "/c";
    memset(cmd_args,0,sizeof(cmd_args));     /* clear the pointer array */

    cmd_args[0] = getenv("COMSPEC");
    cmd_args[1] = batch_command;
                                    /* set up the arguments */
    if((token = strtok(command, wsdelim)) != NULL)
        {
        if(!(cmd_args[arg] = malloc(strlen(token)+1)))
            NoMemoryExit();
        strcpy(cmd_args[arg++], token);
        for( ; token = strtok(NULL, wsdelim); arg++)
            {
            if(!(cmd_args[arg] = malloc(strlen(token)+1)))
                NoMemoryExit();
            strcpy(cmd_args[arg], token);
            }
        }
    if(spawnvp(P_WAIT, cmd_args[2], &cmd_args[2])) /* run the program...... */
        if(cmd_args[0])
            {
            if(spawnvp(P_WAIT, cmd_args[0], cmd_args))
                perror("run (program)");
            }
        else
            printf("COMSPEC= not set in environment, cannot execute\n");

    for( i = 2; i < arg; i++)    /* free each non-NULL pointer */
        free(cmd_args[i]);
    }

void NoMemoryExit(void)
    {
    printf("\nrun: Not enough memory to proceed");
    exit(1);
    }